/**
 * 该文件可自行根据业务逻辑进行调整
 */
import type { RequestClientOptions } from '@vben/request';
import { useAppConfig } from '@vben/hooks';
import { preferences } from '@vben/preferences';
import {
  authenticateResponseInterceptor,
  defaultResponseInterceptor,
  errorMessageResponseInterceptor,
  RequestClient,
} from '@vben/request';
import { useAccessStore, useUserStore } from '@vben/stores';
import { ElMessage } from 'element-plus';
import { useAuthStore } from '#/store';
import { refreshTokenApi, refreshApi } from './core';
import { regex, authPaths, authMethods } from './const';
import { isValidJSON } from '#/utils/isValidJSON'

const { apiURL } = useAppConfig(import.meta.env, import.meta.env.PROD);

function createRequestClient(baseURL: string, options?: RequestClientOptions) {
  const client = new RequestClient({
    ...options,
    baseURL,
  });

  /**
   * 重新认证逻辑
   */
  async function doReAuthenticate() {
    console.warn('Access token or refresh token is invalid or expired. ');
    const accessStore = useAccessStore();
    const authStore = useAuthStore();
    accessStore.setAccessToken(null);
    accessStore.setRefreshToken(null);
    if (
      preferences.app.loginExpiredMode === 'modal' &&
      accessStore.isAccessChecked
    ) {
      accessStore.setLoginExpired(true);
    } else {
      await authStore.logout();
    }
  }

  /**
   * 刷新token逻辑
   */
  async function doRefreshToken() {
    let accesstoken;
    const accessStore = useAccessStore();
    const resp = await refreshTokenApi();
    let { token, refreshToken } = resp;
    accesstoken = token
    // 更新长token,刷新短token
    accessStore.setAccessToken(token);
    accessStore.setRefreshToken(refreshToken);
    return accesstoken;
  }

  function formatToken(token: null | string) {
    return token ? `${token}` : null;
  }

  // 请求头处理
  client.addRequestInterceptor({
    fulfilled: async (config) => {
      const accessStore = useAccessStore();
      const userStore = useUserStore();
      let tenant = userStore?.tenant;
      // 如果是 post、put、patch 请求，需要去除请求体字符串类型字段的首尾空格
      const trimMethods = ['post', 'put', 'patch'];
      // get请求也需要做字符空格处理
      // 递归处理对象，去除所有字符串类型字段的首尾空格
      const trimStringFields = (obj: any): any => {
        if (Array.isArray(obj)) {
          return obj.map((item: any) => trimStringFields(item));
        } else if (obj && typeof obj === 'object') {
          const newObj: any = {};
          for (const key in obj) {
            if (!obj.hasOwnProperty(key)) continue;
            const val = obj[key];
            if (typeof val === 'string') {
              newObj[key] = val.trim();
            } else if (typeof val === 'object' && val !== null) {
              newObj[key] = trimStringFields(val);
            } else {
              newObj[key] = val;
            }
          }
          return newObj;
        }
        return obj;
      };

      // 处理data
      // 仅在 trimMethods 指定的方法中做字符串处理
      // 优化后的处理逻辑：合并方法判断，减少重复代码
      const method = (config.method || '').toLowerCase();

      // 处理 config.data，但排除 FormData 类型
      if (config.data && typeof config.data === 'object' && trimMethods.includes(method) && !(config.data instanceof FormData)) {
        config.data = trimStringFields(config.data);
      }

      if (method === 'get' && config.params && typeof config.params === 'object') {
        config.params = trimStringFields(config.params);
      }
      //添加租户
      if (tenant) {
        config.headers['X-Tenant-ID'] = tenant.tenantId;
      }
      // 判断是否是刷新token的请请求
      if (config.url === refreshApi) {
        config.headers[`Refresh-Token`] = formatToken(accessStore.refreshToken)
      } else {
        config.headers.Authorization = formatToken(accessStore.accessToken);
      }
      //中英文标记
      // config.headers['Accept-Language'] = preferences.app.locale;
      return config;
    },
  });

  // 处理返回的响应数据格式
  client.addResponseInterceptor(
    defaultResponseInterceptor({
      codeField: 'status',
      dataField: 'data',
      pageInfo: 'pageInfo',
      successCode: 200,
      callback: () => { },
    }),
  );

  // token过期的处理
  client.addResponseInterceptor(
    authenticateResponseInterceptor({
      client,
      doReAuthenticate,
      doRefreshToken,
      enableRefreshToken: preferences.app.enableRefreshToken,
      formatToken,
      refreshApi: '/auth/refresh-token'
    })
  );

  // 通用的错误处理,如果没有进入上面的错误处理逻辑，就会进入这里
  client.addResponseInterceptor(
    errorMessageResponseInterceptor((msg: string, error) => {
      // 如果是验证错误，显示错误信息并直接返回
      if ((error as any).isValidationError) {
        ElMessage.error(error.message || msg);
        return;
      }
      
      // 这里可以根据业务进行定制,你可以拿到 error 内的信息进行定制化处理，根据不同的 code 做不同的提示，而不是直接使用 message.error 提示 msg
      // 当前mock接口返回的错误字段是 error 或者 message
      const responseData = error?.response?.data ?? {};
      const errorMessage = responseData?.error ?? responseData?.message ?? error.message ?? '';
      
      // 安全地获取请求URL，避免 undefined 错误
      const requestUrl = error?.config?.url || error?.request?.url || '';

      // 检查状态码7002的特殊处理 - 表单校验错误
      if (responseData?.status === 7002) {
        // 不显示全局错误提示，让表单组件处理
        return;
      }

      // 实名认证的需要单独处理,不做公共处理
      if (![refreshApi, '/system/real-name-authentication'].includes(requestUrl)) {
        // 如果没有错误信息，则会根据状态码进行提示
        ElMessage.error(errorMessage || msg);
      }
    }),
  );

  return client;
}

export const requestClient = createRequestClient(apiURL, {
  responseReturn: 'data',
});

export const baseRequestClient = new RequestClient({ baseURL: apiURL });
